package com.framework.bdf4j.comm.util;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.apache.commons.collections4.CollectionUtils;

import com.framework.bdf4j.comm.Constants;
import com.framework.bdf4j.sysadm.entity.SysDept;
import com.framework.bdf4j.sysadm.entity.SysMenu;
import com.framework.bdf4j.sysadm.vo.MenuVO;
import com.framework.bdf4j.sysadm.vo.Ztree;

/**
 * 权限数据处理
 * 
 */
public class TreeUtils {
    /**
     * 根据父节点的ID获取所有子节点
     * 
     * @param list
     *            分类表
     * @param parentId
     *            传入的父节点ID
     * @return String
     */
    public static List<MenuVO> getChildPerms(List<MenuVO> list, int parentId) {
        List<MenuVO> returnList = new ArrayList<MenuVO>();
        for (Iterator<MenuVO> iterator = list.iterator(); iterator.hasNext();) {
            MenuVO t = (MenuVO)iterator.next();
            // 一、根据传入的某个父节点ID,遍历该父节点的所有子节点
            if (t.getParentId() == parentId) {
                recursionFn(list, t);
                returnList.add(t);
            }
        }
        return returnList;
    }

    /**
     * 递归列表
     * 
     * @param list
     * @param t
     */
    private static void recursionFn(List<MenuVO> list, MenuVO t) {
        // 得到子节点列表
        List<MenuVO> childList = getChildList(list, t);
        t.setChildren(childList);
        for (MenuVO tChild : childList) {
            if (hasChild(list, tChild)) {
                // 判断是否有子节点
                Iterator<MenuVO> it = childList.iterator();
                while (it.hasNext()) {
                    MenuVO n = (MenuVO)it.next();
                    recursionFn(list, n);
                }
            }
        }
    }

    /**
     * 得到子节点列表
     */
    private static List<MenuVO> getChildList(List<MenuVO> list, MenuVO t) {

        List<MenuVO> tlist = new ArrayList<MenuVO>();
        Iterator<MenuVO> it = list.iterator();
        while (it.hasNext()) {
            MenuVO n = (MenuVO)it.next();
            if (n.getParentId().intValue() == t.getMenuId().intValue()) {
                tlist.add(n);
            }
        }
        return tlist;
    }

    List<MenuVO> returnList = new ArrayList<MenuVO>();

    /**
     * 根据父节点的ID获取所有子节点
     * 
     * @param list
     *            分类表
     * @param typeId
     *            传入的父节点ID
     * @param prefix
     *            子节点前缀
     */
    public List<MenuVO> getChildPerms(List<MenuVO> list, int typeId, String prefix) {
        if (list == null) {
            return null;
        }
        for (Iterator<MenuVO> iterator = list.iterator(); iterator.hasNext();) {
            MenuVO node = (MenuVO)iterator.next();
            // 一、根据传入的某个父节点ID,遍历该父节点的所有子节点
            if (node.getParentId() == typeId) {
                recursionFn(list, node, prefix);
            }
            // 二、遍历所有的父节点下的所有子节点
            /*
             * if (node.getParentId()==0) { recursionFn(list, node); }
             */
        }
        return returnList;
    }

    private void recursionFn(List<MenuVO> list, MenuVO node, String p) {
        // 得到子节点列表
        List<MenuVO> childList = getChildList(list, node);
        if (hasChild(list, node)) {
            // 判断是否有子节点
            returnList.add(node);
            Iterator<MenuVO> it = childList.iterator();
            while (it.hasNext()) {
                MenuVO n = (MenuVO)it.next();
                n.setName(p + n.getName());
                recursionFn(list, n, p + p);
            }
        } else {
            returnList.add(node);
        }
    }

    /**
     * 判断是否有子节点
     */
    private static boolean hasChild(List<MenuVO> list, MenuVO t) {
        return getChildList(list, t).size() > 0 ? true : false;
    }

    /**
     * 对象转部门树
     *
     * @param deptList
     *            部门列表
     * @param roleDeptList
     *            角色已存在部门列表
     * @return 树结构列表
     */
    public static List<Ztree> initDeptZtree(List<SysDept> deptList, List<String> roleDeptList) {
        List<Ztree> ztrees = new ArrayList<Ztree>();
        boolean isCheck = CollectionUtils.isNotEmpty(roleDeptList);
        for (SysDept dept : deptList) {
            if (Constants.STATUS_NORMAL.equals(dept.getDelFlag())) {
                Ztree ztree = new Ztree();
                ztree.setId(dept.getDeptId());
                ztree.setpId(dept.getParentId());
                ztree.setName(dept.getName());
                ztree.setTitle(dept.getName());
                if (isCheck) {
                    ztree.setChecked(roleDeptList.contains(dept.getDeptId().toString()));
                }
                ztrees.add(ztree);
            }
        }
        return ztrees;
    }

    /**
     * 菜单树
     *
     * @param menuList
     *            菜单列表
     * @param roleMenuList
     *            角色已存在菜单列表
     * @return 树结构列表
     */
    public static List<Ztree> initMenuZtree(List<SysMenu> menuList, List<Integer> roleMenuList) {
        List<Ztree> ztrees = new ArrayList<Ztree>();
        boolean isCheck = CollectionUtils.isNotEmpty(roleMenuList);
        for (SysMenu menu : menuList) {
            if (Constants.STATUS_NORMAL.equals(menu.getDelFlag())) {
                Ztree ztree = new Ztree();
                ztree.setId(menu.getMenuId());
                ztree.setpId(menu.getParentId());
                ztree.setName(menu.getName());
                ztree.setTitle(menu.getName());
                if (isCheck) {
                    ztree.setChecked(roleMenuList.contains(menu.getMenuId()));
                }
                ztrees.add(ztree);
            }
        }
        return ztrees;
    }

    /**
     * 通过sysMenu创建树形节点
     *
     * @param menus
     * @param root
     * @return
     */
    public static List<SysMenu> buildTree(List<SysMenu> menus, int root) {
        List<SysMenu> trees = new ArrayList<>();
        SysMenu node;
        for (SysMenu menu : menus) {
            node = new SysMenu();
            node.setMenuId(menu.getMenuId());
            node.setParentId(menu.getParentId());
            node.setName(menu.getName());
            node.setPath(menu.getPath());
            node.setPermission(menu.getPermission());
            node.setName(menu.getName());
            node.setIcon(menu.getIcon());
            node.setType(menu.getType());
            node.setSort(menu.getSort());
            node.setHasChildren(true);
            node.setKeepAlive(menu.getKeepAlive());
            trees.add(node);
        }
        return build(trees, root);
    }

    /**
     * 两层循环实现建树
     *
     * @param treeNodes
     *            传入的树节点列表
     * @return
     */
    public static <T extends SysMenu> List<T> build(List<T> treeNodes, Object root) {

        List<T> trees = new ArrayList<>();

        for (T treeNode : treeNodes) {

            if (root.equals(treeNode.getParentId())) {
                trees.add(treeNode);
            }

            for (T it : treeNodes) {
                if (it.getParentId() == treeNode.getMenuId()) {
                    if (treeNode.getChildren() == null) {
                        treeNode.setChildren(new ArrayList<>());
                    }
                    treeNode.add(it);
                }
            }
        }
        return trees;
    }
}
